const dayjs = require('dayjs');
/**
 * 基础业务模块Store模板
 * 各业务模块可基于此模板创建自己的Store
 */

import { observable, action, computed } from 'mobx-miniprogram';
import { cloudHelper, cacheHelper } from '../helpers/index.js';

// 缓存配置
const CACHE_KEY = 'MODULE_STORE'; // 请替换为具体模块名
const CACHE_TIME = 30 * 60; // 30分钟缓存过期

// API路由
const API = {
  LIST: 'module/list',      // 获取列表数据
  DETAIL: 'module/detail',  // 获取详情数据
  ADD: 'module/add',        // 添加数据
  EDIT: 'module/edit',      // 修改数据
  DELETE: 'module/delete',  // 删除数据
  STATUS: 'module/status'   // 变更状态
};

// 创建模块Store
const moduleStore = observable({
  // ==== 状态数据 ====
  
  // 列表数据
  list: [],
  
  // 当前数据项
  current: null,
  
  // 查询条件
  filter: {
    search: '',
    status: '',
    type: '',
    dateRange: null
  },
  
  // 排序
  sort: {
    field: 'createTime',
    order: 'desc' // asc, desc
  },
  
  // 分页数据
  pagination: {
    page: 1,
    size: 20,
    total: 0,
    hasMore: true
  },
  
  // 加载状态
  loading: {
    list: false,
    detail: false,
    submit: false,
    operation: false
  },
  
  // 错误信息
  error: null,
  
  // 缓存信息
  cache: {
    lastUpdate: null,
    isExpired: false,
    autoRefreshInterval: 5 * 60 * 1000 // 5分钟自动刷新
  },
  
  // ==== 计算属性 ====
  
  // 是否为空数据
  get isEmpty() {
    return this.list.length === 0;
  },
  
  // 当前是否有数据加载中
  get isLoading() {
    return Object.values(this.loading).some(status => status === true);
  },
  
  // 是否有筛选条件
  get hasFilter() {
    return this.filter.search || this.filter.status || this.filter.type || this.filter.dateRange;
  },
  
  // 分页信息文本
  get paginationText() {
    return `第${this.pagination.page}页 - 共${this.pagination.total}条`;
  },
  
  // 过滤后的列表数据 - 可以在具体模块中重写此计算属性
  get filteredList() {
    if (this.isEmpty) return [];
    
    // 默认不做额外的过滤，直接返回原始列表
    // 具体模块可以基于业务需求重写此计算属性
    return this.list;
  },
  
  // 按状态分组的数据统计
  get statusStatistics() {
    if (this.isEmpty) return {};
    
    // 按状态统计数量
    const stats = {};
    this.list.forEach(item => {
      const status = item.status || 'unknown';
      stats[status] = (stats[status] || 0) + 1;
    });
    
    return stats;
  },
  
  // 缓存是否过期
  get isCacheExpired() {
    if (!this.cache.lastUpdate) return true;
    
    const now = dayjs().valueOf();
    return (now - this.cache.lastUpdate) > (CACHE_TIME * 1000);
  },
  
  // ==== Action方法 ====
  
  // 初始化
  init: action(function() {
    // 从缓存加载数据
    this.loadFromCache();
    
    // 设置自动刷新定时器
    this._setupAutoRefresh();
  }),
  
  // 重置状态
  reset: action(function() {
    this.list = [];
    this.current = null;
    this.filter = {
      search: '',
      status: '',
      type: '',
      dateRange: null
    };
    this.sort = {
      field: 'createTime',
      order: 'desc'
    };
    this.pagination = {
      page: 1,
      size: 20,
      total: 0,
      hasMore: true
    };
    this.error = null;
    
    // 清除自动刷新定时器
    this._clearAutoRefresh();
  }),
  
  // 设置加载状态
  setLoading: action(function(key, status) {
    this.loading[key] = status;
  }),
  
  // 设置错误信息
  setError: action(function(error) {
    this.error = error;
  }),
  
  // 设置筛选条件
  setFilter: action(function(filter) {
    this.filter = {
      ...this.filter,
      ...filter
    };
    
    // 重置分页
    this.pagination.page = 1;
  }),
  
  // 设置排序
  setSort: action(function(field, order) {
    this.sort = {
      field,
      order
    };
    
    // 重置分页
    this.pagination.page = 1;
  }),
  
  // 加载列表数据
  loadList: action(async function(params = {}, reset = false) {
    try {
      // 检查是否正在加载
      if (this.loading.list) return;
      
      // 设置加载状态
      this.setLoading('list', true);
      this.setError(null);
      
      // 是否重置分页
      if (reset) {
        this.pagination.page = 1;
        this.pagination.hasMore = true;
      }
      
      // 检查是否还有更多数据
      if (!this.pagination.hasMore && !reset) {
        this.setLoading('list', false);
        return;
      }
      
      // 构建请求参数
      const requestParams = {
        page: this.pagination.page,
        size: this.pagination.size,
        sort: this.sort.field,
        order: this.sort.order,
        search: this.filter.search,
        status: this.filter.status,
        type: this.filter.type,
        ...params
      };
      
      // 处理日期范围
      if (this.filter.dateRange) {
        requestParams.startDate = this.filter.dateRange[0];
        requestParams.endDate = this.filter.dateRange[1];
      }
      
      // 节流处理 - 避免短时间内重复请求
      // 如果在200ms内有相同参数的请求，则忽略
      const requestKey = JSON.stringify(requestParams);
      if (this._lastRequestKey === requestKey && 
          (dayjs().valueOf() - this._lastRequestTime) < 200) {
        this.setLoading('list', false);
        return;
      }
      
      this._lastRequestKey = requestKey;
      this._lastRequestTime = dayjs().valueOf();
      
      // 调用云函数
      const result = await cloudHelper.callCloudData(API.LIST, requestParams);
      
      // 处理返回结果
      if (result && result.list) {
        // 处理数据
        const newList = result.list.map(item => this._formatListItem(item));
        
        // 更新状态
        if (reset) {
          this.list = newList;
        } else {
          // 使用Set防止重复数据
          const uniqueItems = new Set([...this.list.map(i => i.id), ...newList.map(i => i.id)]);
          const combinedList = [...this.list];
          
          // 只添加不重复的新项目
          newList.forEach(newItem => {
            if (!this.list.some(item => item.id === newItem.id)) {
              combinedList.push(newItem);
            }
          });
          
          this.list = combinedList;
        }
        
        // 更新分页信息
        this.pagination.total = result.total || 0;
        this.pagination.hasMore = this.list.length < this.pagination.total;
        this.pagination.page++;
        
        // 更新缓存时间戳
        this.cache.lastUpdate = dayjs().valueOf();
        
        // 缓存数据
        this._cacheListData();
      }
      
      return this.list;
    } catch (error) {
      console.error('加载列表数据失败:', error);
      this.setError(error.message || '加载数据失败');
    } finally {
      this.setLoading('list', false);
    }
  }),
  
  // 加载详情数据
  loadDetail: action(async function(id) {
    try {
      // 检查是否正在加载
      if (this.loading.detail) return;
      
      // 设置加载状态
      this.setLoading('detail', true);
      this.setError(null);
      
      // 先从列表中查找，如果有匹配项直接使用
      const itemInList = this.list.find(item => item.id === id);
      if (itemInList) {
        this.current = itemInList;
        this.setLoading('detail', false);
        return this.current;
      }
      
      // 如果列表中没有，再调用云函数
      const result = await cloudHelper.callCloudData(API.DETAIL, { id });
      
      // 处理返回结果
      if (result) {
        // 格式化数据
        this.current = this._formatDetailItem(result);
      }
      
      return this.current;
    } catch (error) {
      console.error('加载详情数据失败:', error);
      this.setError(error.message || '加载详情数据失败');
    } finally {
      this.setLoading('detail', false);
    }
  }),
  
  // 提交数据（添加/编辑）
  submitData: action(async function(data, isAdd = true) {
    try {
      // 检查是否正在提交
      if (this.loading.submit) return;
      
      // 设置加载状态
      this.setLoading('submit', true);
      this.setError(null);
      
      // 调用云函数
      const api = isAdd ? API.ADD : API.EDIT;
      const result = await cloudHelper.callCloudData(api, data);
      
      // 如果是添加操作，将新项目添加到列表
      if (isAdd && result) {
        const newItem = this._formatListItem(result);
        this.list = [newItem, ...this.list];
        
        // 更新缓存
        this._cacheListData();
      } 
      // 如果是编辑操作，更新列表中对应项
      else if (!isAdd && result) {
        const updatedItem = this._formatListItem(result);
        this.list = this.list.map(item => 
          item.id === updatedItem.id ? updatedItem : item
        );
        
        // 如果当前项是被编辑的项，也更新当前项
        if (this.current && this.current.id === updatedItem.id) {
          this.current = updatedItem;
        }
        
        // 更新缓存
        this._cacheListData();
      }
      
      return result;
    } catch (error) {
      console.error('提交数据失败:', error);
      this.setError(error.message || '提交数据失败');
    } finally {
      this.setLoading('submit', false);
    }
  }),
  
  // 删除数据
  deleteData: action(async function(id) {
    try {
      // 检查是否正在操作
      if (this.loading.operation) return;
      
      // 设置加载状态
      this.setLoading('operation', true);
      this.setError(null);
      
      // 调用云函数
      await cloudHelper.callCloudData(API.DELETE, { id });
      
      // 更新列表 - 移除已删除项
      this.list = this.list.filter(item => item.id !== id);
      
      // 如果当前项是被删除的项，清空当前项
      if (this.current && this.current.id === id) {
        this.current = null;
      }
      
      // 更新缓存
      this._cacheListData();
      
      return true;
    } catch (error) {
      console.error('删除数据失败:', error);
      this.setError(error.message || '删除数据失败');
      return false;
    } finally {
      this.setLoading('operation', false);
    }
  }),
  
  // 更新状态
  updateStatus: action(async function(id, status) {
    try {
      // 检查是否正在操作
      if (this.loading.operation) return;
      
      // 设置加载状态
      this.setLoading('operation', true);
      this.setError(null);
      
      // 调用云函数
      await cloudHelper.callCloudData(API.STATUS, { id, status });
      
      // 更新列表中对应项的状态
      this.list = this.list.map(item => {
        if (item.id === id) {
          return {
            ...item,
            status
          };
        }
        return item;
      });
      
      // 如果当前项是被更新的项，也更新当前项
      if (this.current && this.current.id === id) {
        this.current = {
          ...this.current,
          status
        };
      }
      
      // 更新缓存
      this._cacheListData();
      
      return true;
    } catch (error) {
      console.error('更新状态失败:', error);
      this.setError(error.message || '更新状态失败');
      return false;
    } finally {
      this.setLoading('operation', false);
    }
  }),
  
  // 从缓存加载数据
  loadFromCache: action(function() {
    try {
      const cacheData = cacheHelper.get(CACHE_KEY);
      
      if (cacheData && cacheData.list) {
        // 设置数据
        this.list = cacheData.list;
        this.pagination = cacheData.pagination || this.pagination;
        this.filter = cacheData.filter || this.filter;
        this.sort = cacheData.sort || this.sort;
        this.cache.lastUpdate = cacheData.timestamp || dayjs().valueOf();
        
        // 检查缓存是否已过期
        if (this.isCacheExpired) {
          // 缓存已过期，标记需要刷新
          this.cache.isExpired = true;
          
          // 后台自动刷新数据，但不阻塞UI
          setTimeout(() => {
            this.loadList({}, true);
          }, 100);
        }
        
        return true;
      }
      
      return false;
    } catch (error) {
      console.error('从缓存加载数据失败:', error);
      return false;
    }
  }),
  
  // 刷新数据
  refresh: action(async function() {
    // 重置分页
    this.pagination.page = 1;
    this.pagination.hasMore = true;
    
    // 加载数据
    return await this.loadList({}, true);
  }),
  
  // 加载更多数据
  loadMore: action(async function() {
    // 检查是否还有更多数据
    if (!this.pagination.hasMore || this.loading.list) {
      return;
    }
    
    // 加载下一页
    return await this.loadList();
  }),
  
  // ==== 内部辅助方法 ====
  
  // 缓存列表数据
  _cacheListData: function() {
    const cacheData = {
      list: this.list,
      pagination: this.pagination,
      filter: this.filter,
      sort: this.sort,
      timestamp: dayjs().valueOf()
    };
    
    cacheHelper.set(CACHE_KEY, cacheData, CACHE_TIME);
  },
  
  // 格式化列表项
  _formatListItem: function(item) {
    // 默认不做处理
    // 子类可以覆盖此方法进行格式化
    return item;
  },
  
  // 格式化详情项
  _formatDetailItem: function(item) {
    // 默认不做处理
    // 子类可以覆盖此方法进行格式化
    return item;
  },
  
  // 设置自动刷新定时器
  _setupAutoRefresh: function() {
    // 清除旧的定时器
    this._clearAutoRefresh();
    
    // 创建新的定时器
    this._autoRefreshTimer = setInterval(() => {
      // 如果有数据且未处于加载状态，自动刷新
      if (this.list.length > 0 && !this.isLoading) {
        // 悄悄刷新，不显示加载状态
        this.refresh().catch(err => {
          console.error('自动刷新失败:', err);
        });
      }
    }, this.cache.autoRefreshInterval);
  },
  
  // 清除自动刷新定时器
  _clearAutoRefresh: function() {
    if (this._autoRefreshTimer) {
      clearInterval(this._autoRefreshTimer);
      this._autoRefreshTimer = null;
    }
  }
});

// 导出模块Store
export default moduleStore; 